# Python 常用内建函数
'''
高阶函数
排序函数
拼接字函数
最小值、最大值、求和函数
多个可迭代对象聚合
获取当前所有变量
'''

# Python解释器内置了很多函数，你可以直接使用它们。
# 在前面学习过的内建函数有: print()、len()、open()、range()
'''
内建函数                描述
map()            根据提供的函数处理序列中的元素，处理完后返回一个迭代器对象
filter()         用于过滤序列，过滤掉不符合条件的元素，处理完后返回一个迭代器对象
sorted()         对所有可迭代对象进行排序操作
reversed()       返回一个反向的可迭代对象
join()           将序列中的元素以指定的字符连接，生成一个新的字符串
min()            返回可迭代对象中最小的元素
max()            返回可迭代对象中最大的元素
sum()            对可迭代对象求和
zip()            对多个可迭代对象常见一个聚合，返回一个元组的迭代器
locals()         字典格式返回当前范围的局部变量
globals()        字典格式放回当前范围的全局变量
'''
# 更多的内置函数 参考文档: https://docs.python.org/zh-cn/3.8/library/functions.html


# 内建告诫函数： map()、filter()
'''
高阶函数至少满足两个任意的一个条件：
1.能接收一个或多个函数作为输入
2.输出一个函数
'''

# map()函数: 根据提供的函数处理序列中的元素，处理完后返回一个迭代器对象。
'''
语法: map(function,iterable, …)
示例：
num = range(1,11)
def handle(n):
    return n * 2
result = map(handle,num)
print(list(result))
或者使用匿名函数:
result = map(lambda n:n 2, num)
print(list(result))
'''

# 需求：我给你一个列表，请你把列表中的偶数拿出来
'''
a = range(1,11)
b = []
for i in a:
    if i % 2 == 0:
        b.append(i)
print(b)
'''

# 需求：给列表中的每一个元素，都乘以2
'''
def f(n):
    return n * 2
a = range(1,11)
#for i in a:
#    print(f(i))

result = map(f,a)
print(list(result))
#for i in result:
#    print(i)
'''

#def f(n):
#    return n * 2
#a = range(1,11)
#result = map(lambda n:n * 2, a)   #定义匿名函数lambda 传两个参数n n*2
#print(list(result))



# filter()函数: 用于过滤序列，过滤掉不符合条件的元素，处理完后返回一个迭代器对象。
'''
语法: filter(function,iterable)
示例:
mnum = range(1,11)
def handle(n):
    if n % 2 == 0:
        retuen n
result = filter(handle,num)
print(list(result))
或者使用匿名函数:
result = filter(lambda n:n % 2 == 0, num)
print(list(result))    
'''

#a = range(1,11)
#def f (n):
#    if n % 2 == 0:
#        return n
#result = filter(f,a)
#print(list(result))

#result = filter(lambda n:n > 5, a)  #使用匿名函数，只取大于5的数字
#print(list(result))



# sorted函数: 对所有可迭代的对象进行排序操作。
'''
语法: sorted(iterable, *,key=None, reverse=False)
1.key: 指定带有单个参数的函数，用于从interable的每个元素取出比较的键，默认为None（直接比较元素）
2.reverse: 排序规则，True降序，False升序（默认）

示例1: 对序列排序
n = [2,3,4,1,5]
s = ["b","c","a"]
print(sorted(n))
print(sorted(a))

示例2: 对字典中的值排序
dict = {'a':86,"b":23,"c":45}
result = sorted(dict.items(),key=lambda x:x[1])
print(result)
'''

# 需求: 将乱序列表进行排序
n = [8,2,5,1,6,4,7]
s = ["c","a","d","b"]
print(sorted(n))
print(sorted(s))

# 定义一个列表
'''
d = {'鼠标':50,'主机':5000,'键盘':150,'显示器':1000}
#print(d.items())
def f(n):             #定义一个函数 f
    return n[0]       #将结果返回到调用的地方，并把程序的控制权一起返回，程序运行到所遇到的第一个return即返回（退出def块），不会再运行第二个return。

result = sorted(d.items(),key=f, reverse=True)    #以小到大进行排序
result2 = sorted(d.items(),key=f)         #以大到小进行排序
result3 = sorted(d.items(),key=lambda n:n[1], reverse=True)  #使用匿名方式进行排序，以大到小
print(result)
print(result2)
print(result3)
'''


# 反转函数
# reversed()函数: 返回一个反转的迭代器。
'''
语法: reversed(seq)

示例: 列表反向
n = [1,2,3]
print(list(reversed(n)))
'''

z = [1,2,3,4,5,6]           #列表
print(list(reversed(z)))    #列表反转



# 拼接函数
# join()函数: 将序列中的元素以指定的字符连接，生成一个新的字符串。
'''
示例1: 拼接字符串
s = "fengyuanfei"
r = '.'.join(s)

示例2: 拼接序列
computer = ["主机","显示器","鼠标","键盘"]
r = ','.join(computer)
print(r)
'''

s = "fengyuanfei"        #字符串
#for i in s:
#    print(i + ".",end="")         #for循环 方式拼接
print('.'.join(s))            #以.分割 拼接（分隔符并不是必须的）

computer = ["主机","显示器","鼠标","键盘"]       #序列
print('：：：'.join(computer))      #以，分割 拼接



# 最小值、最大值、求和函数
'''
min() 返回可迭代对象中最小的元素
max() 返回可迭代对象中最大的元素
sum() 可迭代对象求和
'''

t = [7,1,2,3,4,5,6,7,8,9]
print(min(t))     #求最小的元素
print(max(t))     #求最大的元素
print(sum(t))     #求列表中所有元素的和



# 获取当前所有变量
'''
globals(): 字典格式返回当前范围的全局变量
locals(): 字典格式返回当前范围的局部变量

示例:
a = 1
def f():
    b = 2
    print("局部变量: %s" % locals())
print("全局变量: %s" %globals())
f()
'''

w = 1  #全局变量
def f():
    e = 2  #局部变量
    print(locals())
f()
print(globals())



# 多迭代对象聚合
# zip()函数: 对多个可迭代对象创建一个聚合，返回一个元组的迭代器。
'''
示例:
x = [1,2,3]
y = [4,5,6]
zipped = zip(x,y)
print(list(zipped))
'''


g = [1,2,3]
h = [4,5,6]
zipped = zip(g,h)
print(list(zip(g,h)))    #等同于 print(list(zipped))
# 打印的结果 [(1, 4), (2, 5), (3, 6)]

for x,y in zip(g,h):
    print(x,y)